Sparse Encodings for Control Signals

ABSTRACT

This document discloses techniques, apparatuses, and systems for sparse encodings for control signals. Integrated circuits (ICs) may transmit various signals to manage interactions between circuit components of the IC. These critical signals are common targets for malicious attacks because, when altered, they can cause the IC to perform differently than is intended, and in some cases, bypass security measures. To protect against these attacks, the sparse encodings for control signals described herein transmit critical signals with sparse encodings. Further, multiple rails may be used to transmit a single bit of the sparsely encoded critical signals across each rail. In this way, the techniques described herein may provide a scalable solution that may be adjusted differently based on each implementation.

BACKGROUND

Electronic devices often include at least one integrated circuit (IC) that enables various functionalities on an electronic device. To perform some of these functionalities securely, an electronic device may store or operate with secret information that is restricted to certain access levels within the IC. An attacker may attempt to gain unauthorized access to this secret information of the electronic device to compromise and/or alter the operations of the IC. Existing approaches to prevent unauthorized access, however, are often inadequate to combat evolving software, hardware, and wireless attacks employed by malicious actors who attempt to access the secret information of electronic devices.

SUMMARY

This document discloses techniques, apparatuses, and systems for sparse encodings for control signals. Integrated circuits (ICs) may transmit various signals to manage interactions between circuit components of the IC. These critical signals are common targets for malicious attacks because, when altered, they can cause the IC to perform differently than is intended, and in some cases, bypass security measures. To protect against these attacks, the sparse encodings for control signals described herein transmit critical signals with sparse encodings. Further, multiple rails may be used to transmit a single bit of the sparsely encoded critical signals across each rail. In this way, the techniques described herein may provide a scalable solution that may be adjusted differently based on each implementation.

An IC is described that includes a first component and a second component. In aspects, the first component and the second component are coupled to one another through a plurality of separate data lines. Sparsely encoded signals having a minimum Hamming distance are used to communicate between the first and the second component. Each of the plurality of data lines may communicate a single bit of the sparsely encoded signal. In this way, the IC may be protected against fault injection attacks.

A method is also described that includes transmitting a first signal from a first component of an IC to a second component of the IC using a first data line of a plurality of data lines that couple the first component to the second component. The first signal may be indicative of a first bit of a sparsely encoded signal that is communicated between the first component and the second component. In aspects, the sparsely encoded signal has a minimum Hamming distance to protect the IC against fault injection attacks. The method also includes transmitting a second signal from the first component to the second component using a second data line of the plurality of data lines. In aspects, the second signal is indicative of a second bit of the sparsely encoded signal that is different than the first bit of the sparsely encoded signal. The second component may receive the first signal and the second signal and perform a circuit operation based on the first signal and the second signal.

This Summary is provided to introduce simplified concepts for implementing sparse encodings for control signals. The simplified concepts are further described below in the Detailed Description. This Summary is not intended to identify essential features of the claimed subject matter, nor is it intended for use in determining the scope of the claimed subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

The details of one or more aspects of the described techniques, apparatuses, and systems for sparse encodings for control signals are described below. The use of the same reference numbers in different instances in the description and the figures indicate similar elements:

FIG. 1 illustrates an example operating environment that includes electronic devices that may implement sparse encodings for control signals;

FIG. 2 illustrates an example implementation of example security circuitry which includes multiple circuit components that can be implemented to support aspects of sparse encodings for control signals;

FIG. 3-1 illustrates an example cryptographic intellectual property (IP) block that can implement sparse encodings for control signals in accordance with one or more aspects;

FIG. 3-2 illustrates an example cryptographic IP block 116 that can implement sparse encodings to protect control signals and handshakes from security-undermining attacks in accordance with one or more aspects;

FIG. 3-3 illustrates example separate data lines for communicating a sparsely encoded signal between a first circuit component and a second circuit component;

FIG. 4 illustrates an example method for transmitting sparsely encoded signals using multiple rails; and

FIG. 5 illustrates an example electronic device that may implement sparse encodings for control signals.

DETAILED DESCRIPTION

In general, there are a variety of methods that attackers may use to gain access to privileged information (e.g., keys) maintained by an integrated circuit (IC). For example, fault injection attacks may be used to inject faults into signals transmitted between different circuit components of an integrated circuit. Various methods may be used to inject faults into an IC. For example, faults may be injected into an IC by using high-powered lasers, exposing the IC to electromagnetic interference, adjusting a clock of the IC, altering the power supply of an IC, or a combination of these methods. In some implementations, lasers may be used to inject faults with high accuracy. For example, a high-powered laser may be directed to the surface of a transistor to flip the transistor and transmit a signal with a different value.

ICs may use different signals to control circuit operations and, more specifically, manage interactions between different circuit components. In this way, these critical signals may directly affect or control which operations are performed by the IC as well as when the operations are performed. When faults are injected along with (or in place of) these signals, ICs may perform unintended operations and, in some cases, bypass security measures (e.g., secure boot/root-of-trust processes). For example, faults may be injected into handshakes to cause the IC to prematurely release intermediate values that are in the process of undergoing circuit operations. In this way, attackers may obtain or gain access to privileged information about the circuit (e.g., secret keys) by bypassing operations that have not yet been performed when the values are prematurely released. In other implementations, the values themselves may be indicative of privileged information maintained by the integrated circuit (e.g., the value may be representative of a private key used by the IC).

To protect against these attacks, the techniques discussed below utilize sparse encodings for signals (e.g., critical signals) transmitted between two circuit components. For example, each signal may be defined such that it has a predetermined minimum Hamming distance (e.g., the number of bits that are different between any two valid solutions). Specifically, if a value is representable in a one-bit representation (e.g., 1′b0 for LOW (e.g., as defined by transmitting a low voltage value) or 1′b1 for HIGH (e.g., as defined by transmitting a high voltage value)) and the predetermined minimum Hamming distance is three, a LOW value may be represented as 3′b010 and the HIGH value may be represented as 3′b101. In this way, an attacker may attempt to flip multiple bits instantaneously (or within a small amount of time) to successfully inject a fault that creates a different valid solution.

Generally, in information theory, the Hamming distance between two data items of equal length (e.g., 32 bits) is the number of positions at which corresponding symbols or bit positions of the data items are different. For example, given two integers that are each represented by 16 bits and where each integer is a respective valid solution, the Hamming distance between these two integers can be the number of positions at which corresponding bits are different between the two 16-bit data structures.

In aspects, the HIGH and LOW values may be represented as a mix of one and zero bits to increase the difficulty in a successful fault injection attack. In general, it may be easier to flip all bits within a signal to a single value (either HIGH or LOW e.g., one or zero). Thus, at least one HIGH bit and at least one LOW bit may be used to represent each sparsely encoded signal. To transmit the sparsely encoded signals, the IC described below may utilize multiple rails (e.g., wires or buses) that each carry a single bit of the sparsely encoded signal. Due to the mix in values, the multiple rails may include both positive rails and negated rails, which is explained further with respect to FIG. 3-1 .

In some implementations, the multiple rails may transmit critical signals between two components of the IC. As a specific example, the multiple rails may communicatively couple a finite state machine (FSM) to another circuit component to transmit control signals (e.g., initializations, acknowledgements, terminations) between the FSM and the circuit component. Some control signals are single bit signals that may be represented as either a single HIGH or a single LOW value. By communicating these signals with sparse encodings across multiple rails, the IC may become less susceptible to fault injection attacks. In aspects, a sparsely encoded signal (e.g., sparse encodings) may include signaling (e.g., transmitted logic values) having a set of encoded values with non-adjacent codewords and/or codewords with a Hamming distance of at least two. For example, valid codewords, transmitted as bits on separate data lines, are codewords that may not be obtained from another codeword by glitching or flipping one bit value during an attack.

In yet another aspect, each of the multiple rails may be connected to a check module that may be used to compare the transmitted signal to a plurality of valid states, thus allowing for the IC to check for possible fault injection attempts. If the check module determines that the transmitted signal does not match any of the predefined valid states, the check module may signal an error and begin an error handling process. As such, the techniques, systems, and apparatuses for sparse encodings for control signals described below may provide an economical and scalable solution to safeguard ICs, including protecting ICs from fault injection attacks.

FIG. 1 illustrates an example environment 100 that includes an apparatus 102 in which aspects of sparse encodings for control signals can be implemented. The apparatus 102 may be implemented as any suitable device, some of which are illustrated as a smart-phone 102-1, a tablet computer 102-2, a laptop computer 102-3, a gaming console 102-4, a desktop computer 102-5, a server computer 102-6, a wearable computing device 102-7 (e.g., smart-watch), and a broadband router 102-8 (e.g., mobile hotspot). Although not shown, the apparatus 102 may also be implemented as any of a mobile station (e.g., fixed- or mobile-STA), a mobile communication device, a client device, a user equipment, a mobile phone, an entertainment device, a mobile gaming console, a personal media device, a media playback device, a health monitoring device, a drone, a camera, an Internet home appliance capable of wireless Internet access and browsing, an IoT device, and/or other types of electronic devices. The apparatus 102 may provide other functions or include components or interfaces omitted from FIG. 1 for the sake of clarity or visual brevity.

The apparatus 102 includes an integrated circuit 104 (IC 104) that utilizes one or more processors 106 and computer-readable media 108, which may include memory media or storage media. The processors 106 may be implemented as a general-purpose processor (e.g., of a multicore central-processing unit (CPU) or application processor (AP)), an application-specific integrated circuit (ASIC), graphics processing unit (GPU), or a system on chip (SoC) with other components of the apparatus 102 integrated therein. The CRM 108 can include any suitable type of memory media or storage media, such as read-only memory (ROM), programmable ROM (PROM), random access memory (RAM), dynamic RAM (DRAM), static RAM (SRAM), or Flash memory. In the context of this discussion, the computer-readable media 108 of the apparatus 102 is implemented as at least one hardware-based or physical storage device, which does not include transitory signals or carrier waves. Applications, firmware, and/or an operating system (not shown) of the apparatus 102 can be embodied on the computer-readable media 108 as processor-executable instructions, which may be executed by the processor 106 to provide various functionalities described herein. The computer-readable media 108 may also store device data 110, such as user data or user media that is accessible through the applications, firmware, or operating system of the apparatus 102.

In this example, the IC 104 contains security circuitry 112. The apparatus 102, the IC 104 the security circuitry 112, or any combination thereof may implement a secure cryptographic processor. The security circuitry 112 may be implemented using one or more circuit components 114, for example, circuit component 114-1 through circuit component 114-n. The circuit components 114 may be organized to perform any number of operations to enable functionality of the apparatus 102. Examples of circuit components include a processor and multiple functional components as described in FIG. 2 . The security circuitry 112 can be realized as, for example, a protected enclave, a trusted chip platform, a hardware-based root of trust (RoT) chip (e.g., a silicon RoT), and so forth. Regardless of how or where the security circuitry 112 is incorporated into an electronic device, the security circuitry 112 may counter many different types of attacks.

The security circuitry 112 may include at least one cryptographic (crypto) intellectual property (IP) block 116 that performs various cryptographic operations of the IC 104. In some implementations, the at least one cryptographic IP block 116 may be implemented within an advanced encryption security (AES) unit. In aspects, the AES unit or the cryptographic IP block 116 may implement one or more cryptographic operations (e.g., an operation of encrypting data or decrypting data). The data may include, for example, image data (e.g., captured by a camera or video camera) or sound data (e.g., captured by a microphone). In one example, the pseudo-random or true-random number values may be used to generate a private/public key pair. The public key may be transmitted out of the apparatus 102 via the transceivers 126 and/or the I/O ports 128. The private key may be used to decrypt data (e.g., image/sound data) received by the apparatus 102 via the transceivers 126 and/or the I/O ports 128, and which is encrypted using the public key. Alternatively or additionally, data (e.g., obtained using the sensors 130), such as image or sound data, may be hashed using the private key to generate a hash digest, and the data and the hash digest may be transmitted out of the apparatus 102, via the transceivers 126 and/or the I/O ports 128, such that the hash digest functions as a signature for the data, which a third party can verify using the public key.

In another example, the cryptographic IP block 116 may perform Boolean masking and remasking operations on data operated on by the IC 104 based on pseudo-randomness provided by the pseudo-random or true-random number generator. The cryptographic IP block 116 may handle device secrets that are used to ensure the appropriate usage and performance of the IC 104, for example, cryptographic keys or other privileged information. To protect the privileged information handled by the cryptographic IP block 116, cryptographically secure operations may be performed to protect against various attacks that may release device secrets or information about the IC 104.

In aspects, the cryptographic IP block 116 may be configured to perform cryptographically secure operations in accordance with secure multi-rail control of sparsely encoded signals, as described herein. For example, the cryptographic IP block 116 may contain one or more finite state machines (FSMs 118) that control operations of a cryptographic processor within the IC 104. As further described with respect to FIG. 3-1 , the cryptographic IP block 116 may contain a main control FSM that manages interactions of the cryptographic IP block 116 and the processors 106. For example, the main control FSM may transmit signals that control when values are written to registers to be accessed by the processors 106. The FSMs 118 may also include a core control FSM (shown in FIG. 3-1 ) that coordinates internal operations of the cryptographic IP block 116.

The cryptographic IP block 116 may include multiple rails 120 between different components, for example the FSMs 118, of the cryptographic IP block 116. As shown in the example of FIG. 3-3 , the rails 120 may be used to transmit sparsely encoded signals between different components of the cryptographic IP block 116 or the IC 104. Specifically, each of the rails 120 may communicate a single bit of the sparsely encoded signal between the first and the second circuit component. In aspects, each of the separate data lines 120-1, 102-2, 120-3, 120-4 . . . 120-n, of the rails 120 can be dynamically configurable to communicate one or more sparse encoding signals using variations of a given data structure. For example, a respective data structure for each sparse encoding signal can be a sequence of bits. The number of bits in a data structure can be less than or equal to the quantity of data lines 120-n, where n is an integer greater than one.

In aspects, each of the separate data lines 120-1, 102-2, 120-3, 120-4 . . . 120-n may be dynamically configurable based on a rail configuration signal(s) 324. The rail configuration signal(s) 324 is an example control signal that can be generated in hardware, software, or both. For example, the rail configuration signal(s) 324 can be transmitted to the cryptographic IP block 116 in response to being generated using control logic of the security circuitry 112, the IC 104, or a combination of these. In some implementations, the rail configuration signal(s) 324 may be generated locally at the cryptographic IP block 116.

As described above, the sparsely encoded signals may be represented through a combination of HIGH and LOW bits. Therefore, the rails 120 may contain both positive and negated rails. In some implementations, a positive rail may carry a HIGH signal, whereas a negated rail may carry a LOW signal. In some other implementations, a signal carried by a particular rail (e.g., a negated rail) may be inverted to convey a desired signal state (e.g., a HIGH signal). In aspects, negated rails, or a component (e.g., FSM) that transmits one or more bits of the signal across the negated rails, may include an inverter that inverts the output of the value that is communicated by the first component. This also applies to positive rails or a component that transmits one or more bits of the signal across the positive rails. For example, if an FSM wants to transmit a HIGH signal (e.g., a one), a negated rail may carry a LOW signal and the inverter of that FSM can invert that LOW signal to a HIGH signal. Thus, a LOW signal may be carried as a HIGH signal over a negated rail and a HIGH signal may be carried as a LOW signal over a positive rail. In aspects, any one of the separate data lines 120-1, 120-2, 120-3, 120-4 . . . 120-n may be used (or configured) as a positive rail or a negated rail.

In some implementations, the rails 120 may be coupled to at least one check module (not shown) to ensure that the sparsely encoded signal transmitted across the rails 120 is representative of a valid signal state (e.g., the predetermined HIGH and LOW signal representations). The check module may compare a transmitted signal to a set of predetermined valid states of the critical signals that is stored within the check module (or elsewhere in the CRM 108). If the check module determines that the transmitted signal does not correspond to a valid signal state, for example, if the signal has been injected with a fault, an error may be passed up-chain to be handled appropriately (described further with respect to FIG. 2 ).

As shown, the security circuitry 112 is coupled to an interconnect 122. The interconnect 122 can be realized using, for example, a bus, a switching fabric, or a bus network that enables the various circuit components to communicate. Each of the circuit components 114 may be directly or indirectly coupled to the interconnect 122. Although described with respect to the cryptographic IP block 116, any portion of the interconnect 122 may utilize multiple rails (e.g., buses or wires) to enable the use of sparsely encoded signals. In other words, sparse encodings may be used to communicate signals between any two components of the IC 104, not just those within the cryptographic IP block 116. In some examples, the interconnect 122 may transmit all signals using multiple rails and sparse encodings. In other examples, sparse encodings may only be implemented for critical signals (e.g., signals that directly control operations of the IC 104 or are used to facilitate operations that involve privileged data, such as private keys).

The apparatus 102 may also include a display 124, transceivers 126, input/output ports (I/O ports 128) and/or sensors 130. The display 124 may be operably coupled with one of the processors 106 (e.g., graphics processing unit (GPU)) and configured to graphically present an operating system or applications of the apparatus 102. The transceivers 126 may be configured to enable wired or wireless communication of data (e.g., device data 110) over wired or wireless networks according to any suitable communication protocol. The I/O ports 128 of the apparatus 102 may include universal serial bus (USB) ports, coaxial cable ports, and other serial or parallel connectors (including internal connectors) useful to couple the electronic device to various components, peripherals, or accessories such as keyboards, microphones, or cameras.

The apparatus 102 also includes sensors 130, which enable the apparatus 102 to sense various properties, variances, stimuli, or characteristics of an environment in which the apparatus 102 operates. For example, the sensors 130 may include various motion sensors, ambient light sensors, acoustic sensors, capacitive sensors, infrared sensors, temperature sensors, radar sensors, or magnetic sensors. Alternatively, or additionally, the sensors 130 may enable interaction with, or receive input from, a user of apparatus 102, such as through touch sensing or proximity sensing.

FIG. 2 illustrates an example implementation 200 of example security circuitry 112 which includes multiple circuit components, including multiple example circuit components 114, that can be implemented to support aspects of sparse encodings for control signals. As shown, the security circuitry 112 includes a processor 106 that is coupled to an interconnect 122. Each of the processors 106, the multiple memories, and the multiple other circuit components 114 may be directly or indirectly coupled to the interconnect 122. In aspects, the components of FIG. 2 may be embodied as a secure computing platform or a secure System-on-Chip that implements a RoT and/or other secure cryptographic features.

In example implementations, the multiple memories can include a read-only memory (ROM 202), a static random-access memory (SRAM 204), and a flash memory 206. In aspects, the ROM 202, SRAM 204, or the flash memory 206 may be implemented within the security circuitry 112 or within computer-readable media (e.g., computer-readable media 108). The multiple circuit components 114 can include an alert handler 208, an AES unit, a cryptographic IP block 116 internal to or external from the AES unit, a hash-based message authentication code (HMAC) engine (HMAC engine 210), and a serial peripheral interface (SPI) device (SPI device 212). The multiple circuit components 114 can also include a universal asynchronous receiver/transmitter (UART) unit (UART unit 214), a general-purpose input/output (GPIO) interface (GPIO interface 216), a pin multiplexer (pin mux 218), and a pad controller 220. The multiple circuit components 114 can further include a random number generator (RNG 222) and a timer 224. Additionally, the circuit components 114 can include any of the memories, as shown in FIG. 2 . Although certain examples of memories and other circuit components 114 are depicted in FIG. 2 or described herein, a given implementation of the security circuitry 112 may include more, fewer, and/or different instances of processors, controllers, memories, modules, or peripheral devices, including duplicates thereof.

The illustrated circuit components 114 can be operated synchronously, or asynchronously, based on one or more clock signals. Although not shown in FIG. 2 , the security circuitry 112 may include at least one clock generator to generate the clock signals or may include reset circuitry to reset one or more individual components independently of each other, multiple components jointly, or an entire IC chip. Alternatively, the security circuitry 112 may receive at least one clock signal or a reset signal from a source that is external to the security circuitry 112, which source may or may not be on a separate chip. One or more separate circuit components 114 may operate in respective individual clock domains. For instance, circuit components 114 may be synchronized to a clock that is local to a respective component. Circuit components 114 in different clock domains may operate or communicate asynchronously with respect to one another.

Example implementations of the illustrated circuit components 114 are described below. The processor 106 may be realized as a “main,” “central,” or “core” processor for the security circuitry 112. The processor 106 may, by way of example only, be implemented with a 32 bit, in-order reduced instruction set computing (RISC) core with a multi-stage pipeline. With, e.g., an RISC-V functionality, the processor 106 may implement an M (machine) and a U (user) mode. Activating a reset pin (not shown) (e.g., through de-assertion of an active-low reset pin) may cause the processor 106 to exit reset and begin executing code at its reset vector. The reset vector may begin in the ROM 202, which validates code in the emulated embedded flash (e-flash) before jumping to it. In other words, the code is expected to have been instantiated into the e-flash before the reset is released. In some cases, resets throughout the security circuitry 112 can be made asynchronous active-low as per a comportability specification to support interoperability among the various circuit components. A reset may be generated by the alert handler 208 as a security countermeasure, by a watchdog timer, and so forth. Reset signals may also be sent to other circuit components, such as one of the memories or one of the other circuit components 114.

Coupled to the processor 106 may be a debug module (DM) 226 and an interrupt controller (ItC) 228, either of which may also be made comportable. The debug module 226 provides debug-access to the processor 106. By interfacing with certain pins of the IC, logic in the debug module 226 allows the processor 106 to enter a debug mode and provides an ability to inject code into the device (e.g., by emulating an instruction) or into a memory. The interrupt controller 228 may be disposed proximate to the processor 106. The interrupt controller 228 can accept a vector of interrupt sources from within the security circuitry 112. The interrupt controller 228 can also assign leveling and priority to the interrupts before forwarding them to the processor 106 for handling.

The processor 106 can provide any desired level of performance or include any internal circuit components. For example, the processor 106 can include at least one arithmetic logic unit (ALU) (e.g., including an “additional” ALU to calculate branch targets to remove a cycle of latency on taken conditional branches) and multiple pipeline stages. With multiple pipeline stages, a pipeline can perform register writeback to reduce a cycle of latency from loads and stores and prevent a pipeline stall where a response to a load or store is available the cycle after the request. The processor 106 can implement a single-cycle multiplier or produce an imprecise exception on an error response to a store, which allows the processor to continue executing past the store without waiting for the response. Although not depicted, the processor 106 specifically, or the security circuitry 112 generally, can include an instruction cache to provide single-cycle access times for instructions.

In the illustrated example implementation 200, the components of the security circuitry 112 include or have access to three memory address spaces for instructions and data. The ROM 202 is the target for the processor 106 after release of a reset. The ROM 202 contains hard-coded instructions to perform a subset of platform checking before checking the next stage of code. The next stage of code (e.g., a boot loader stored in e-flash memory) can be the first piece of code that is not hard-coded into the silicon of the device. This next stage of code is, therefore, signature-checked for integrity to increase security. The ROM 202 can execute this signature check by implementing, for example, a Rivest-Shamir-Adleman-check (RSA-check) algorithm on the full contents of the boot loader.

The flash memory 206 can be implemented as e-flash memory for code storage. This e-flash can house the boot loader mentioned herein, as well as an operating system and applications that layer on top. The SPI device 212 can be used to bulk-load the e-flash memory. The debug module 226 may also be used for code loading. The SRAM 204 can be operated as a scratch pad SRAM that is available for data storage by the processor 106 (e.g., for stack and heap information). The SRAM 204 can also store code.

The security circuitry 112 can include circuit components 114 that may be subservient execution units that are coupled to the processor 106 via the interconnect 122. Each of these circuit components 114 can follow an interface framework that ensures comportability with each other and with the processor 106. A comportability scheme can specify how the processor 106 communicates with a given circuit component 114 (e.g., using the interconnect 122), how a circuit component communicates 114 with the processor 106 (e.g., using interrupts), how a circuit component 114 communicates security events (e.g., using alert indications) to other circuit components 114, like the alert handler 208; how a circuit component communicates with peripheral devices (e.g., through a chip I/O); or combinations thereof. The depicted circuit components 114 can include circuit components relative to the alert-related functionality provided by the alert handler 208, relative to the processor 106, relative to one or more the memories, relative to a chip I/O, and so forth. Thus, the memories can also comprise components relative to each other or the other depicted circuit components 114.

Security circuitry (e.g., chip I/O) may further include the pin mux 218 and the pad controller 220. The pin mux 218 provides signaling routes between at least a portion of the circuit components 114 and available multiplexable I/O nodes of the security circuitry 112 (e.g., pins of the chip in which the various components are integrated or an interface to other portions of an SoC). The pad controller 220 manages control or pad attributes like drive strength, technology, pull up versus pull down, and the like of each of the circuits' components. The pin mux 218 and the pad controller 220 may themselves be peripheral devices on the interconnect 122. Accordingly, each may include, or may otherwise be associated with, at least one collection of registers that provide software configurability.

The UART unit 214 can implement UART features, such as single-lane duplex UART functionality. The outputs and inputs thereof can be configured to connect to any circuit I/O via the pin mux 218. The GPIO interface 216 creates G bits of bidirectional communication to external circuitry via the pin mux 218, where G is a positive integer like 16, 32, or 64. Regarding memory I/O, the SPI device 212 can implement a firmware mode. Here, the firmware mode can enable a feature that provides the ability for external drivers to send firmware upgrade code into a bank of the flash memory 206 for in-field firmware updates. The firmware mode can include addressing of the memories using SPI transactions. Although not depicted, the security circuitry 112 can include an inter-integrated circuit (I2C) host to enable command of I2C devices. This command of I2C devices may include standard, full, and fast modes.

Several “core security” components are also depicted, including the encryption engines and the alert handler 208. The cryptographic IP core 116, which may be implemented as described with reference to FIG. 1 , can provide various symmetric encryption and decryption functionalities, such as by using one or more protocols and/or varying key sizes, like 128 b, 192 b, or 256 b. In aspects, the cryptographic IP block 116 may be incorporated within an AES unit and may implement methods described herein. The component can select encryption or decryption of data that arrives in (e.g., 16-byte quantities to be encrypted or decrypted using different block cipher modes of operation). The cryptographic IP block 116 can support electronic codebook (ECB) mode, cipher block chaining (CBC) mode, cipher feedback (CFB) mode, output feedback (OFB) mode, counter (CTR) mode, and the like. Data transfer can be made processor-available (e.g., key and data material may be passed into the cryptographic engine via register writes). Alternatively, private channels for the transfer of key and data material may be included to reduce exposure from potentially untrusted processor activity.

The HMAC engine 210 may utilize, for instance, a secure hash algorithm (SHA) SHA-256 as a hashing algorithm. SHA-256 is a member of the SHA-2 family of hashing algorithms in which the digest (or hash output) is of 256b length, regardless of the data size of the input to be hashed. The data is sent into the HMAC engine 210 after declaring the beginning of a hash request. This zeroes out the internal state to initial conditions (e.g., 32b at a time). Once the data has been sent by a component client, the client can indicate the completion of the hash request (with optional partial-word final write). In accordance with an example portability interface scheme, the HMAC engine 210 produces the hash result and makes it available for register read by the requesting client. The data transfer may be made processor-available or may be made private to reduce exposure to potentially untrusted processor activity.

HMAC is a message authentication protocol layered on top of a hashing function (e.g., SHA-256), and HMAC mixes in a secret key for cryptographic purposes. HMAC is a particular application of appending the secret key in a prescribed manner, such as twice, around the hashing (via SHA-256) of the message. To provide this functionality, a 256b key may be programmed into the circuit component before the message hash begins. The timing of authentication completion can vary and may be longer in latency than using native SHA-256. Here again, the hashing information or the secret key may be made processor-available for convenience or processing efficiency or may be rendered private in some manner for increased security.

The alert handler 208 is responsible for processing and responding to alerts (e.g., errors), including ones provided from other circuit components 114, for example the check module. The alerts can be considered security-sensitive interrupts that are to be handled in a timely manner to respond to a perceived security threat. Unlike “standard” interrupts, alerts may not be handled solely by software executing on the processor 106. Alerts can trigger a first-stage request to be handled by software as a “regular” interrupt. If, however, the software is not able to respond and properly remedy the alert-triggered interrupt, then the alert handler 208 triggers a second-stage response. The second-stage response can include enacting a security countermeasure, including terminating a process, erasing or otherwise deleting data, withdrawing power from a circuit portion, or resetting an IC chip or portion thereof. This ensures that the underlying issue (e.g., the perceived security threat) is addressed even if the processor 106 is busy, wedged, or also under attack.

Thus, an alert can be implemented as an elevated interrupt-type signal or alert indication that the alert handler 208 receives from other circuit components 114 and that is indicative of a potential security threat. In operation, the alert handler 208 can gather alerts from other circuit components 114 of the security circuitry 112 and convert them into interrupts that the processor 106 can address. If the processor 106 does not clear the interrupt, however, the alert handler 208 provides hardware responses to address the potential security threat.

In general, the alert handler 208 may store some indication of an alert that is received from any of the circuit components 114. In some cases, this indication may be presented after the IC 104 or the one or more circuit components 114 perform a reset. As a specific example, the alert handler 208 may write a time, location, or type of alert to a register and allow operation of the IC 104 or the circuit components 114 to continue normal operation. Once the operations are finished, or a predetermined period of time has passed, the resulting data may be discarded so that privileged information is not revealed and the operation of the IC 104 is not altered due to the potential event that caused the alert. In this way, a malicious agent may be unable to determine when an alert is provided to the alert handler 208.

The security circuitry 112 can also include the RNG 222. Generally, randomness can contribute to the security functionality by providing variations in execution that can keep attackers from predicting a good time to launch an attack. A random number, for instance, can provide secret material used for identity and cryptographic purposes. The RNG 222 can be seeded into algorithmic computation to obscure sensitive data values. Generally, the RNG 222 provides better performance as its number generation increasingly becomes truly random and to the extent it can also be hardened against attack. In some cryptographic processes, strong randomness guarantees may not be required. The RNG 222 may be implemented as a “true” RNG (TRNG), which may involve a design having an analog portion to take advantage of some physical event or process that is non-deterministic. Example TRNG designs rely on metastability, electronic noise, timing variations, thermal noise, quantum variation, and so forth. The TRNG filters the resulting variable(s) and sends them into a pool of entropy that the device can sample at a given time for a current randomized function. In some cases, an interface to the entropy pool can include a read request of available random bits. The TRNG interface indicates how many bits are available, and the requesting circuit components or software can read from this pool to the extent bits are available. Attempted reading of entropy bits that are not available can trigger an interrupt or an alert.

Two other components of the circuit components 114 include the timer 224 and a flash controller (not shown), the latter of which is described in the following paragraph. The timer 224 can, for example, support accurate performance by the processor 106. The timer 224 is formed from multiple bits (e.g., 64 bits) and operates as a free-running timer with a guaranteed frequency to within some percentage. The timer 224 may enable the circuit components 114 to determine appropriate time intervals to perform operations. For example, the FSMs 118 or other components of the cryptographic IP block 116 may transmit or receive signals in accordance with the timer 224. Another timer (not explicitly shown) can act as a watchdog timer to backstop the processor 106 in case the processor becomes unresponsive. The unresponsiveness may be due to development code that is wedged, a security attack, and so forth.

Although not shown, a flash controller may control the flash memory 206, which is available for code and data storage. The primary read path for this data can be in the standard memory address space. Writes to that address space can be ignored, however, because flash is not written to in a standard way. Instead, to write to the flash memory 206, software interacts with the flash controller. The flash functionality can include three primary commands: read, erase, and program. Read commands can be standardized and can use the chip memory address space. Erase commands are performed at a page level, where the page size is parameterizable by the flash controller. Upon receiving an erase request, the flash controller wipes the contents of the target page, which renders the data into a “1” state (e.g., 0xFFFFFFFF per word). Afterward, software can program individual words to any value. A flash bit is not returned to a “1” state without another erase, so future content is effectively changed with an AND of the current content and the written value. Erase and program commands are relatively slow. A typical erase time is measured in milliseconds, and program times are in the range of microseconds. Security is also a concern because secret data may be stored in the flash memory 206. Some memory protection can therefore be provided by the flash controller.

The security circuitry 112 is depicted in FIG. 2 with a particular set of circuit components 114. A given security circuitry 112 can, however, have more, fewer, or different circuit components. The circuit components may also be interconnected differently or operate in manners besides those example manners described herein. Further, some circuit components 114 may be omitted while other circuit components 114 are implemented in multiple instances. For example, the alert handler 208 may be duplicated or distributed, or multiple cryptographic IP blocks 116 may be present in some security circuitry 112. Further, a GPIO interface 216 may be omitted from among the components 114 of security circuitry 112 for IC chips in which the security circuitry 112 forms but one core among dozens.

In aspects, any of the circuit components 114 may include a cryptographic processor 230 that executes the cryptographic operations of the component. In some implementations, the cryptographic processor 230 is separate from the processor 106 of FIG. 1 . In other implementations, the cryptographic processor 230 is implemented within the processors 106. Further, any of the circuit components 114 may include a cryptographic processor 230 (or processing core) to perform the specific functions of that component.

FIG. 3-1 illustrates an example cryptographic IP block 116 that can implement sparse encodings for control signals in accordance with one or more aspects. The cryptographic IP block 116 can provide symmetric encryption and decryption using one or more protocols and varying key sizes, like 128b, 192b, or 256b. The component can select encryption or decryption of data that arrives in, for example, 16-byte quantities to be encrypted or decrypted using different block cipher modes of operation.

The cryptographic IP block 116 may be attached to the IC interconnect 122 as a peripheral module. Communication with the processor may be performed through a set of control and status registers 302 that may input or output data, keys, and/or status and control information. In aspects, the registers 302 may provide an interface where a key manager may provide or receive keys without exposing them to the processor or other hosts attached to the IC interconnect 122. The cryptographic IP block 116 contains multiple components that are communicatively coupled to one another through one or more rails 120. In aspects, the rails 120 that carry critical signals are represented by thick arrows in FIG. 3-1 , and these rails 120 may include multiple rails that implement sparse encodings for control signals.

As illustrated, the cryptographic IP block 116 includes a main control FSM 304 that controls access to software, registers, and other portions of the IC, and a cryptographic core 306 (e.g., an example of the cryptographic processor 230), including a core control FSM 308 that controls the operations of circuit components within the cryptographic core 306. The main control FSM 304 and core control FSM 308 may communicate handshake signals across the rails 120. In aspects, the main control FSM 304 may transmit signals to the core control FSM 308 to initiate and terminate operations of the cryptographic core 306. For example, when data is input to the registers 302, the main control FSM 304 may transmit a handshake signal to the core control FSM 308 along the rails 120 to indicate that data has been input to the register 302 to undergo cryptographic operations. In response, the core control FSM 308 may transmit a handshake signal to the main control FSM 304 along the rails 120 to acknowledge or accept the request for the cryptographic core 306 to perform operations on the data input to the registers 302. The main control FSM 304 may then transmit a signal to the registers 302 to release the data to the cryptographic core 306 and/or to write lock the registers 302 from inputting or outputting data.

To begin operations, the core control FSM 308 may transmit multiplexer (MUX) selector signals to the MUXs 310 to multiplex the input data (e.g., using MUX 310-1) or the input key (e.g., using MUX 310-2). In aspects, the data and/or keys may be masked based on randomness provided to the MUXs 310. Once the data and/or the key has been multiplexed, the core control FSM 308 may transmit a write enable signal along the rails 120 to the state register 312 and/or to the key register 314 to enable the data/key to be written to the respective register.

The data and key may then be passed to data path logic 316 where various operations are performed on the values. For example, the data may undergo non-linear operations within the data path logic 316. The data path logic 316 may include any number of substitution boxes or Galois-Field (GF) multipliers. The data path logic 316 may perform multiple rounds of encryption/decryption on the data using the key. To protect against various attacks, the data path logic 316 may execute a number of parallel operations using multiple substitution boxes. The core control FSM 308 may communicate various signals to circuit components within the data path logic 316 to enable or disable operations within the data path logic 316 or to acknowledge that an operation has been performed.

Once the data has passed through the data path logic 316, it may be multiplexed again using a set of MUXs 318. The core control FSM 308 may transmit MUX selector signals that control the operation of the MUXs 318 using rails 120 and rails 120. In doing so, the data may be multiplexed at the MUX 318-1 to create the encrypted/decrypted data after a first round of operations, and the key may be multiplexed at the MUX 318-2 to create the round key that is used for encryption/decryption during the next round of operations. The data and the round key may then be passed back through the MUXs 310 and into the state register 312 and the key register 314 for another iteration of encryption/decryption.

When the data has finished operations (e.g., the data has completed all rounds of encryption/decryption), the core control FSM 308 may transmit a handshake signal to the main control FSM 304 across the rails 120 to indicate that data is ready to be output to the registers 302. In response, the main control FSM 304 may transmit a handshake signal across the rails 120 to acknowledge or accept the request to release the data to the registers. The main control FSM 304 may then transmit a signal to the registers 302 (e.g., a write enable signal or a read enable signal) along the rails 120 to allow the data to be written to the registers and then released along the interconnect 122. As a result, the data may be output from the cryptographic core 306 and written to the registers 302.

As described above, various signals may be transmitted by the main control FSM 304 or the core control FSM 308 to manage operations of the cryptographic IP block 116 and, as a result, handshake signals and other control signals inside cryptographic and other IP blocks are a common target for fault injection attacks. By successfully injecting a single fault into such a signal, an IC may terminate a current operation early, start a new operation early, or release intermediate data, thereby enabling a series of other attacks. In some instances, these attacks are directed to cryptographic IP blocks because cryptographic IP blocks may maintain privileged information or may be used to implement security features, such as a secure boot process or root-of-trust.

FIG. 3-2 illustrates an example cryptographic IP block 116 that can implement sparse encodings to protect control signals and handshakes from security-undermining attacks in accordance with one or more aspects. In some example cases, critical signals (e.g., handshakes and other control signals) may be targeted by fault injection attacks that utilize targeted lasers to flip transistors within the IP block. As an example, by changing a bit of a critical signal, logic flow may be redirected to terminate execution of a chip process, release intermediate data relevant to a chip process, or to repeat a process out of order.

As illustrated in FIG. 3-2 , these attacks may be directed at a variety of locations 322 where handshakes and/or control signals are communicated. For example, a malicious actor may direct attacks at a first location 322-1 where handshakes are communicated between the main control FSM 304 and the core control FSM 308. A malicious actor may be motivated to attack communicated handshakes at the first location 322-1 to initiate new operations of the cryptographic core or to notify a main IP block of an available output from the cryptographic core 306. In another example, a malicious actor may direct attacks at a second location 322-2 where the core control FSM 308 may transmit a control signal to the state 312 and key 314 registers maintained in the cryptographic core 306. In still another example, a malicious actor may direct attacks at a third location 322-3 where multiplexer control signals are communicated. A malicious actor may be motivated to attack multiplexer control signals to initiate and/or alter multiplexer (e.g., MUXs 318-1, MUXs 318-2) operations within the cryptographic core 306. In a still further example, a malicious actor may direct attacks at a fourth location 322-4 where control signals (e.g., a write enabled signal in response to an output from the cryptographic core 306) are transmitted from the main control FSM 304 to the registers 302 to control interactions of the registers 302. In addition to the above descriptions, attacks at one or more of these locations 322 may occur simultaneously, chronologically, and/or at altogether separate intervals. The information released as a result of the fault injection attacks or logic redirections may provide privileged information about the on-chip logic to an attacker that can be used to bypass security measures or design other attacks on the IC. With respect to a cryptographic IP block (e.g., cryptographic IP block 116), fault injection attacks may enable the release of cryptographic private keys to an unprivileged individual or system.

To withstand such attacks (e.g., fault injection attacks), the cryptographic IP block 116 can implement sparse encodings for control signals and handshakes. In some implementations, the described sparse encoding may be utilized at any point (e.g., locations 322) where sensitive operations are occurring on a hardware device, for example, any processes that involve access control or a privileged level of operation (e.g., power, register access, system resets). Further, in some examples, the described secure multi-rail control logic may be implemented within cryptographic IP blocks only. In aspects, a sparsely encoded signal (e.g., sparse encodings) may include signaling (e.g., transmitted logic values) having a set of encoded values with non-adjacent codewords and/or codewords with a Hamming distance of at least two. For example, valid codewords, transmitted as bits on separate data lines, are codewords that may not be obtained from another codeword by glitching or flipping one bit value during an attack.

In general, critical signals may have bit representations that do not require a set minimum Hamming distance. Thus, a fault injection attack may be able to alter these signals into an unintended but otherwise valid state, thereby directly influencing operation of the IC. For example, when handshakes are altered, out of order or untimely interactions may be initiated between the cryptographic IP block 116 and the cryptographic core 306 (e.g., an untimely output or termination from the cryptographic core 306). As another example, manipulating the operations of the MUX devices (e.g., MUXs 310 or MUXs 318) may directly influence the data output to the registers 302 (e.g., influence what type of data is latched).

To protect against fault injection attacks, sparse encoding may be used for any of the critical signals that directly influence circuit operation. For example, instead of using a single bit representation to communicate critical signals over a single wire (or rail), n wires may be used for these critical signals where n is greater than one. In this way, each of the rails 120 that are used to connect circuit components may communicate a single bit of a sparsely encoded signal. Further, critical signals may require the use of a minimum Hamming distance such that the flip of a single bit (or a number of bits less than the Hamming distance) does not result in a valid solution. Specifically, an attacker may be required to flip a same number of bits as the minimum Hamming distance simultaneously (or in a short amount of time) to alter the critical signal to a different valid signal. As a non-limiting example, the minimum Hamming distance may be between 2 and 5 bits, however, it should be appreciated that the minimum Hamming distance may be scaled to increase security hardening. For a two-state signal (e.g., one bit; HIGH or LOW), the quantity of rails 120 (e.g., between any two components) may be the same as the minimum Hamming distance. Thus, the quantity of rails 120 may be a scalable parameter for security hardening.

In a non-security hardened case, a bit representation of a valid signal may be 1′b1 and another valid signal may be represented as 1′b0. As such, a single bit flip may alter one valid signal to a different valid signal. In contrast, as an example of the sparse encoding described, a bit representation of one valid signal may be 3′b101, while a second valid signal may be 3′b010. In this case, the Hamming distance is three, as three bits must be altered to achieve a different valid signal. A larger Hamming distance may harden the security parameters of the cryptographic IP block 116, as attackers would need to flip multiple bits of a signal simultaneously to maliciously alter a signal to a different valid signal. This may be particularly difficult, as fault injection attacks using a laser may require separate lasers to each trigger different transistors at a same time (or within a short period of time) to flip multiple bits of a signal. Stated generally, an attacker would have to insert a same number of faults as the Hamming distance to trigger a successful attack (e.g., generate a successful signal).

In some implementations, valid signals should be chosen such that the bit representation does not include all bits having a same binary value. For example, in a three-bit scenario, the bit representation of a valid signal should not be 3′b111 or 3′b000. In general, attackers may have more success flipping all the bits in a signal to a single value than flipping multiple single bits of a word to a different value. For example, attackers may be able to clear a word by converting all bits in the word to a binary value of zero or a binary value of one. Thus, valid signals may be defined to contain both zero and non-zero bits to increase the security of the IC against fault injection attacks.

To communicate valid signals as a mix of HIGH and LOW bits, negated rails may be implemented that include negated logic. For example, if a first component wishes to transmit a HIGH value (e.g., 1′b1), the HIGH three-bit signal may be chosen to be (3′b100). In this example, the rail that transmits the most significant bit is a positive rail because it transmits the same value that is communicated by the first component. In contrast, the rail that carries the second most significant bit and the rail that carries the third most significant bit are negated rails because they carry a different value than is transmitted from the first component. In this example, a HIGH value (e.g., 1′b1) would be transmitted as 3′b100, and a LOW value (e.g., 1′b0) would be transmitted as 3′b011. As shown, the positive and negative rails may be determined once the multi-bit representation of the HIGH or the LOW value is determined. Once determined, the multi-bit signals may be automatically generated by placing inverters on the negative rails or at the output of the transmitting component (e.g., the FSM). As a result, the sparsely encoded signals may be represented as a combination of both HIGH and LOW signals. In implementations, the inverters can be merged into (e.g., integrated with) a given rail (e.g., through proper instruction of the synthesis tool).

Given that increasing the Hamming distance of valid signal values may require larger word size (e.g., more bits to describe a value), elements of the cryptographic IP block 116 may be designed to accommodate the larger number of bits used for each signal. For example, MUX devices (e.g., MUXs 310 and MUXs 318) operating on the values may now be required to support a larger number of bits. Additionally, other logic (e.g., data path logic 316) or registers (e.g., registers 302, state register 312, or key register 314) within the cryptographic IP block 116 may need to change to accommodate the larger Hamming distances. In this way, the components may operate natively in the higher-bit format.

In aspects, the multi-bit size of MUX control signals provides additional challenges when utilizing sparse encoding to increase security. For example, a MUX control signal may require more bits to reach a same minimum Hamming distance when compared to a control signal that can be represented by a single bit. In these cases, the quantity of rails 120 may be greater than the minimum Hamming distance.

In this way, these techniques may provide a scalable solution where the number rails 120 may be scaled based on security, spatial, and cost constraints without requiring the design of new custom logic. Moreover, these techniques can scale with the advancement of attacks. For example, if an attacker is now able to flip three bits simultaneously, the quantity of rails 120 and the minimum Hamming distance may be increased to at least four.

In addition to using sparse encoding to increase the minimum Hamming distance between valid signals, check modules 320 may be placed in areas where handshakes or control signals are communicated. For example, check modules 320 may be placed on rails 120 between the main control FSM 304 and the registers 302, check modules 320 may be placed on rails 120 between the main control FSM 304 and the core control FSM 308, or check modules 320 between the core control FSM 308 and a cryptographic core register (e.g., state register 312 or key register 314) or MUX device (e.g., MUXs 310 or MUXs 318).

The check modules 320 may monitor the signals transmitted across the rails 120 and check to ensure that the signals communicated are representative of a valid encoding (e.g., no fault has been injected). For example, a check module of the check modules 320 may store a set of predetermined valid states that a signal passed across the rails 120 may represent. For a signal that transmits either a HIGH or LOW value, the check module may store the multi-bit representation of the HIGH value and the multi-bit representation of the LOW state. For signals that cannot be represented in only two states (e.g., MUX selector signals), the corresponding check module 320 may include a set of valid states that contains more than two valid states. In storing the set of predetermined valid states, the check modules 320 may compare a signal passed along the rails 120 to the predetermined set of valid states and determine if the signal matches any valid state within the set of valid states. If the signal matches any of the valid states, the IC or the cryptographic IP block 116 may continue normal operation. If a signal passed from a first component to a second component is determined not to be representative of a valid encoding (e.g., it is not within the list of valid states because a fault injection attack has occurred), an error may be flagged and passed up-chain for error handling.

In aspects, error handling may be changed based on the specific implementation. For example, when an error is triggered by the check module (e.g., it is suspected that a fault injection attack occurred) the control FSMs may be locked or reset to limit the ability to alter the processes executing on the cryptographic IP block 116. In other implementations, a shutdown or reset of the entire IC may be triggered when a sufficient number of errors is reached. In general, to restore the state of a locked FSM or a locked chip, the device may need to be reset. In another example, the process may continue to the termination of a current process, but the output will be discarded. In this manner, an attacker may be unable to tell when an attack triggers an error and the mechanisms of the security system may remain hidden. In general, errors detected by the check modules 320 may be handled in a number of ways, as described with respect to the alert handler of FIG. 2 . In general, however, the check modules 320 may keep record of errors determined by storing an indication of the error in a register of the IC to ensure the cryptographic IP block 116 is aware that an error occurred.

By implementing check modules 320 along the rails 120, the cryptographic IP block 116 may determine if a fault injection attack occurs before circuit operations may be altered by the attack. Moreover, to trigger a successful fault injection, attackers may be required to inject multiple faults into a signal simultaneously, or within a short amount of time. For example, a first valid solution passed may have the bit representation 3′b100. During a first attack, the attacker may flip the first bit of the signal to have a bit representation of 3′b000. Later in a second attack, the attacker may flip a second bit of the signal to 3′b010. Finally, in a third attack, the attacker may flip a third bit of the signal to generate the valid solution 3′b011. Without a check module 320 at a location near the handshake or control signal, the cryptographic IP block 116 may act on the valid signal 3′b011 even though it has been altered by a fault injection attack.

If check modules 320 are implemented, however, the cryptographic IP block 116 may be able to identify the signal resulting from the first or second attack as an invalid signal and trigger an alert. As such, the check modules may be able to determine a fault injection attack even when the final result is a valid signal. In some implementations, the check modules may detect an attack even when bits are flipped in quick succession. In this way, an attacker attempting to flip multiple bits to reach a different valid signal may need to flip each bit simultaneously, which may require multiple lasers and precise timing. Further, the check modules may increase the overall difficulty of performing a successful fault injection attack because the changed signal will be checked soon after the attack. In this way, a potential attacker may have to flip the multiple bits correctly in a single attempt.

In some implementations, the check modules 320 between the main control FSM 304 and the core control FSM 306 may be removed from the cryptographic IP block 116 because faults injected into these signals will propagate through to a signal controlling the data path (e.g., write enabled signals or MUX selector signals) and be flagged by the check modules 320 placed on those rails 120. As such, circuit space and cost may be conserved without negatively impacting the security of the IC.

FIG. 4 illustrates an example method 400 for transmitting sparsely encoded signals using multiple rails. Method 400 is illustrated as a set of blocks that specify operations that may be performed but are not necessarily limited to the order or combinations shown for performing the operations by the respective blocks. Further, any of one or more of the operations may be repeated, combined, reorganized, or linked to provide a wide array of additional and/or alternate methods. The techniques are not limited to performance by one entity or multiple entities operating on one device. In some aspects, operations or acts of the method 600 are implemented by or managed by a cryptographic IP block 116, an FSM (e.g., main control FSM 304 and/or core control FSM 308), and/or any of the circuit components 114. For clarity, the method is described with reference to the elements of FIGS. 1 through 3 .

At 402, a first signal indicative of a first bit of a sparsely encoded signal is transmitted by a first component and to a second component over a first rail that communicatively couples the first component to the second component. In aspects, the first rail is a single rail from the plurality of rails 120. The first rail may be a positive rail or a negated rail. The first component or the second component may be a main control FSM 304, a core control FSM 308, a register (e.g., registers 302, state register 312, or key register 314), a MUX device (e.g., MUXs 310 or MUXs 318), or any other circuit component 114 within the IC 104. In aspects, the sparsely encoded signal may be indicative of a handshake signal, a write enabled signal, a register setting, or a MUX selector signal. Moreover, the first signal may be a HIGH signal or a LOW signal.

At 404, a second signal indicative of a second bit of the sparsely encoded signal is transmitted by the first component to the second component over the first rail that communicatively couples the first component to the second component. The second rail may be a different rail than the first rail from the plurality of rails 120. In aspects, the second signal may be a HIGH or a LOW signal. In some implementations, at least one of the first or second rail is a negated rail so that the sparsely encoded signal may be represented as a combination of HIGH and LOW values.

At 406, the first signal and the second signal are received at the second component. In aspects, the first rail and the second rail are coupled to a check module 320, and the output of the check module 320 is coupled to the second component. The check module 320 may store a plurality of predetermined valid states within its own memory or any other memory of the IC. The check module 320 may compare the sparsely encoded signal to the predetermined valid states stored in memory. If the sparsely encoded signal does not match a predetermined valid state of the sparsely encoded signal, the check module 320 may output an error 502 to the alert handler 208. If the sparsely encoded signal does match a predetermined valid state, the sparsely encoded signal may be output from the check module 320 to the second component.

At 408, the IC 104 performs a circuit operation based on the first signal and the second signal. For example, the IC 104 may perform a write to memory, a MUX operation, or any other circuit operation. In aspects, the circuit operation may be used to perform encryption or decryption of data. As such, the first component and the second component may be implemented within a cryptographic IP block 116 of the IC 104. Alternatively, either one of or both of the first and second component may be implemented outside the cryptographic IP block 116 but within the IC 104.

FIG. 5 illustrates various components of an example electronic device 500 that can implement sparse encodings for control signals in accordance with one or more aspects. The electronic device 500 may be implemented as any single or multiple of a fixed, mobile, stand-alone, or embedded device; in any form of a consumer, computer, portable, user, server, communication, phone, navigation, gaming, audio, camera, messaging, media playback, and/or other type of electronic device 500, such as the smartphone that is depicted in FIG. 1 as the apparatus 102. One or more of the illustrated components may be realized as discrete components or as integrated components on at least one IC of the electronic device 500. Generally, the various components of the electronic device 500 are coupled via an interconnect 122 and/or one or more fabrics that support communication between the components in accordance with one or more aspects of sparse encodings for control signals.

The electronic device 500 can include one or more communication transceivers 126 that enable wired and/or wireless communication of device data 110, such as received data, transmitted data, or other information identified herein. Example communication transceivers 126 include near-field communication (NFC) transceivers, wireless personal area network (PAN) (WPAN) radios compliant with various IEEE 802.15 (Bluetooth™) standards, wireless local area network (LAN) (WLAN) radios compliant with any of the various IEEE 802.11 (WiFi™) standards, wireless wide area network (WAN) (WWAN) radios (e.g., those that are Third Generation Partnership Project compliant (3GPP-compliant)) for cellular telephony, wireless metropolitan area network (MAN) (WMAN) radios compliant with various IEEE 802.16 (WiMAX™) standards, infrared (IR) transceivers compliant with an Infrared Data Association (IrDA) protocol, and wired local area network (LAN) (WLAN) Ethernet transceivers.

The electronic device 500 may also include one or more data input ports 128 via which any type of data, media content, and/or other inputs can be received, such as user-selectable inputs, messages, applications, music, television content, recorded video content, and any other type of audio, video, and/or image data received from any content and/or data source, including a sensor like a microphone or a camera. The data input ports 128 may include USB ports, coaxial cable ports, fiber optic ports for optical fiber interconnects or cabling, and other serial or parallel connectors (including internal connectors) for flash memory, DVDs, CDs, and the like. These data input ports 128 may be used to couple the electronic device to components, peripherals, or accessories such as keyboards, microphones, cameras, or other sensors.

The electronic device 500 of this example includes at least one processor 106 (e.g., any one or more of application processors, microprocessors, digital signal processors (DSPs), controllers, and the like), which can include a combined processor and memory system (e.g., implemented as part of an SoC), that processes (e.g., executes) computer-executable instructions to control operation of the device. The processor 106 may be implemented as an application processor, embedded controller, microcontroller, security processor, artificial intelligence (AI) accelerator, and the like. Generally, a processor or processing system may be implemented at least partially in hardware, which can include components of an integrated circuit or on-chip system, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), a complex programmable logic device (CPLD), and other implementations in silicon and/or other materials.

Alternatively or additionally, the electronic device 500 can be implemented with any one or combination of electronic circuitry, which may include software, hardware, firmware, or fixed logic circuitry that is implemented in connection with processing and control circuits, which are generally indicated at 502 (as electronic circuitry 502). This electronic circuitry 502 can implement executable or hardware-based modules (not shown in FIG. 5 ), such as through processing/computer-executable instructions stored on computer-readable media, through logic circuitry and/or hardware (e.g., such as an FPGA), and so forth.

In aspects, the electronic device 500 includes an interconnect 122, which may include any one or more of a system bus, interconnect, crossbar, data transfer system, or other switch fabric that couples the various components within the device to enable various aspects of signaling and/or communication with sparse encoding. A system bus or interconnect can include any one or a combination of different bus structures, such as a memory bus or memory controller, a peripheral bus, parity blocks, error correction code (ECC) blocks, a universal serial bus, and/or a processor or local bus that utilizes any of a variety of bus architectures.

The electronic device 500 also includes one or more memory devices 504 that enable data storage, examples of which include random access memory (RANI), non-volatile memory (e.g., read-only memory (ROM), flash memory, erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM)), and a disk storage device. Thus, the memory device(s) 504 can be distributed across different logical storage levels of a system as well as at different physical components. The memory device(s) 504 provides data storage mechanisms to store the device data 110, other types of code and/or data, and various device applications 506 (e.g., software applications or programs). For example, an operating system 508 can be maintained as software instructions within the memory device 504 and executed by the processor 106.

In some implementations, the electronic device 500 also includes an audio and/or video processing system 510 that processes audio data and/or passes through the audio and video data to an audio system 512 and/or to a display system 514 (e.g., a video buffer or a screen of a smartphone or camera). The audio system 512 and/or the display system 514 may include any devices that process, display, and/or otherwise render audio, video, display, and/or image data. Display data and audio signals can be communicated to an audio component and/or to a display component via an RF (radio frequency) link, S video link, HDMI (high-definition multimedia interface), composite video link, component video link, DVI (digital video interface), analog audio connection, video bus, or other similar communication link, such as a media data port 516. In some implementations, the audio system 512 and/or the display system 514 are external or separate components of the electronic device 500. Alternatively, the display system 514, for example, can be an integrated component of the example electronic device 500, such as part of an integrated touch interface.

The electronic device 500 of FIG. 5 is an example implementation of the apparatus 102 of FIG. 1 , an example implementation of a device that can implement sparse encodings for control signals as described with reference to FIG. 1 through FIG. 4 . The electronic device 500 can thus include security circuitry 112, which can be a separate IC chip or included as part of another IC chip or device, like the processor 106, the electronic circuitry 502, or the memory device 504. Accordingly, one or more of the illustrated components may be integrated on the same IC chip, like an SoC, or at least on a single printed circuit board (PCB).

The security circuitry 112 may include a cryptographic IP block 116 that performs cryptographically safe operations using encryption or decryption. The cryptographic IP block 116 may include any various circuit components that are configured to communicate sparsely encoded signals according to one or more aspects of sparse encodings for control signals. For example, the cryptographic IP block 116 may include multiple rails that each transmit a single bit of the sparsely encoded signals. Each of the multiple rails may be communicatively coupled to one of a plurality of FSMs that communicate a respective bit of the sparsely encoded signal over the respective rail. The principles of sparse encodings for control signals as described herein can therefore be implemented by, or in conjunction with, the electronic device 500 of FIG. 5 .

Unless context dictates otherwise, use herein of the word “or” may be considered use of an “inclusive or,” or a term that permits inclusion or application of one or more items that are linked by the word “or” (e.g., a phrase “A or B” may be interpreted as permitting just “A,” as permitting just “B,” or as permitting both “A” and “B”). Also, as used herein, a phrase referring to “at least one of” a list of items refers to any combination of those items, including single members. For instance, “at least one of a, b, or c” can cover a, b, c, a-b, a-c, b-c, and a-b-c, as well as any combination with multiples of the same element (e.g., a-a, a-a-a, a-a-b, a-a-c, a-b-b, a-c-c, b-b, b-b-b, b-b-c, c-c, and c-c-c, or any other ordering of a, b, and c). Further, items represented in the accompanying figures and terms discussed herein may be indicative of one or more items or terms, and thus reference may be made interchangeably to single or plural forms of the items and terms in this written description. Although implementations for a secure cryptographic processor have been described in language specific to certain features and/or methods, the subject of the appended claims is not necessarily limited to the specific features or methods described. Rather, the specific features and methods are disclosed as example implementations for secure cryptographic processing.

Examples of sparse encodings for control signals are provided below:

Example 1: An integrated circuit comprising: a first component; a second component; a plurality of separate data lines configured to communicate, between the first component and the second component, a sparsely encoded signal having a minimum Hamming distance, each data line of the plurality of separate data lines is configured to communicate a single bit of the sparsely encoded signal.

Example 2: The integrated circuit as recited by any of the previous examples, wherein the first component or the second component are any one of: a finite state machine; a multiplexer device; a storage register; or a configuration and settings register.

Example 3: The integrated circuit as recited by any of the previous examples, wherein the sparsely encoded signal is indicative of: a handshake between the first component and the second component; a register setting configured by one of the first component or second component; a write enabled control signal between the first component and the second component; or a multiplexer selector control signal between the first component and the second component.

Example 4: The integrated circuit as recited by any of the previous examples, wherein the plurality of separate data lines include: at least one positive data line; and at least one negated data line that is configured to carry a signal that is different than a signal carried by the at least one positive data line.

Example 5: The integrated circuit as recited by any of the previous examples, wherein the at least one negated data line includes an inversion circuit configured to invert an output of a single bit of the sparsely encoded signal, the single bit to be communicated using the respective negated data line.

Example 6: The integrated circuit as recited by any of the previous examples, wherein the plurality of separate data lines comprises a number of data lines that is the same as the minimum Hamming distance of the sparsely encoded signal.

Example 7: The integrated circuit as recited by any of the previous examples, wherein the number of data lines is between two data lines and five data lines.

Example 8: The integrated circuit as recited by any of the previous examples, further comprising a cryptographic intellectual property block that includes the first component, the second component, and the plurality of separate data lines.

Example 9: The integrated circuit as recited by any of the previous examples, further comprising: a check module coupled to the plurality of separate data lines, the check module configured to determine a validity of information represented by the sparsely encoded signal communicated using the plurality of separate data lines.

Example 10: The integrated circuit as recited by any of the previous examples, wherein the check module is configured to: store a predefined set of valid states; compare the predefined set of valid states and the sparsely encoded signal communicated using the plurality of separate data lines; and determine whether the sparsely encoded signal matches any one valid state of the predefined set of valid states based on the comparison between the predefined set of valid states and the sparsely encoded signal.

Example 11: The integrated circuit as recited by any of the previous examples, wherein the check module is configured to report an error in response to the determination that the sparsely encoded signal does not match any one valid state of the predefined set of valid states.

Example 12: A method comprising: transmitting, by a first component of an integrated circuit, to a second component of the integrated circuit, and using a first data line of a plurality of data lines that couple the first component to the second component, a first signal indicative of a first bit of a sparsely encoded signal transmitted over the plurality of data lines, the sparsely encoded signal having a minimum Hamming distance; transmitting, by the first component, to the second component, and using a second data line of the plurality of data lines, a second signal indicative of a second bit of the sparsely encoded signal, the second bit different than the first bit; and receiving, at the second component, the first signal and the second signal.

Example 13: The method as recited by any of the previous examples, further comprising performing, by the second component, a circuit operation based on the first signal and the second signal received at the second component.

Example 14: The method as recited by any of the previous examples, wherein the first component or the second component are any one of: a finite state machine; a multiplexer device; a storage register; or a configuration and settings register.

Example 15: The method as recited by any of the previous examples, wherein the sparsely encoded signal is indicative of: a handshake between the first component and the second component; a register setting configured by one of the first component or second component; a write enabled control signal between the first component and the second component; or a multiplexer selector control signal between the first component and the second component.

Example 16: The method as recited by any of the previous examples, wherein: the second data line is a negated data line; and transmitting the second signal comprises: inverting the second bit of the sparsely encoded signal; and transmitting a third signal that is indicative of the inverted second bit of the sparsely encoded signal.

Example 17: The method as recited by any of the previous examples, further comprising: comparing, based on the first signal and the second signal and by a check module of the integrated circuit, the sparsely encoded signal and a predetermined set of valid states stored by the check module; and determining whether the sparsely encoded signal matches any valid state of the predetermined set of valid states.

Example 18: The method as recited by any of the previous examples, further comprising: in response to the determination that the sparsely encoded signal matches any valid state of the predetermined set of valid states, receiving the first signal and the second signal at the second component.

Example 19: The method as recited by any of the previous examples, further comprising: in response to the determination that the sparsely encoded signal does not match any valid state of the predetermined set of valid states, outputting an error to the integrated circuit.

Example 20: The method as recited by any of the previous examples, wherein outputting the error to the integrated circuit comprises storing an indication of the error in a memory of the integrated circuit.

Although aspects of the described apparatuses, systems, and methods for implementing sparse encodings for control signals have been described in language specific to features and/or methods, the subject of the appended claims is not necessarily limited to the specific features or methods described. Rather, the specific features and methods are disclosed as example implementations of sparse encodings for control signals, and other equivalent features and methods are intended to be within the scope of the appended claims. Further, various aspects of sparse encodings for control signals are described, and it is to be appreciated that each described aspect can be implemented independently or in connection with one or more other described aspects. 

What is claimed is:
 1. An integrated circuit comprising: a first component; a second component; and a plurality of separate data lines configured to communicate, between the first component and the second component, a sparsely encoded signal having a minimum Hamming distance, each data line of the plurality of separate data lines is configured to communicate a single bit of the sparsely encoded signal.
 2. The integrated circuit of claim 1, wherein the first component or the second component are any one of: a finite state machine; a multiplexer device; a storage register; or a configuration and settings register.
 3. The integrated circuit of claim 1, wherein the sparsely encoded signal is indicative of: a handshake between the first component and the second component; a register setting configured by one of the first component or second component; a write enabled control signal between the first component and the second component; or a multiplexer selector control signal between the first component and the second component.
 4. The integrated circuit of claim 1, wherein the plurality of separate data lines include: at least one positive data line; and at least one negated data line that is configured to carry a signal that is different than a signal carried by the at least one positive data line.
 5. The integrated circuit of claim 4, wherein the at least one negated data line includes an inversion circuit configured to invert an output of a single bit of the sparsely encoded signal, the single bit to be communicated using the respective negated data line.
 6. The integrated circuit of claim 1, wherein the plurality of separate data lines comprises a number of data lines that is the same as the minimum Hamming distance of the sparsely encoded signal.
 7. The integrated circuit of claim 6, wherein the number of data lines is between two data lines and five data lines.
 8. The integrated circuit of claim 1, further comprising a cryptographic intellectual property block that includes the first component, the second component, and the plurality of separate data lines.
 9. The integrated circuit of claim 1, further comprising: a check module coupled to the plurality of separate data lines, the check module configured to determine a validity of information represented by the sparsely encoded signal communicated using the plurality of separate data lines.
 10. The integrated circuit of claim 9, wherein the check module is configured to: store a predefined set of valid states; compare the predefined set of valid states and the sparsely encoded signal communicated using the plurality of separate data lines; and determine whether the sparsely encoded signal matches any one valid state of the predefined set of valid states based on the comparison between the predefined set of valid states and the sparsely encoded signal.
 11. The integrated circuit of claim 10, wherein the check module is configured to report an error in response to the determination that the sparsely encoded signal does not match any one valid state of the predefined set of valid states.
 12. A method comprising: transmitting, by a first component of an integrated circuit, to a second component of the integrated circuit, and using a first data line of a plurality of data lines that couple the first component to the second component, a first signal indicative of a first bit of a sparsely encoded signal transmitted over the plurality of data lines, the sparsely encoded signal having a minimum Hamming distance; and transmitting, by the first component, to the second component, and using a second data line of the plurality of data lines, a second signal indicative of a second bit of the sparsely encoded signal, the second bit different than the first bit; and receiving, at the second component, the first signal and the second signal.
 13. The method of claim 12, further comprising performing, by the second component, a circuit operation based on the first signal and the second signal received at the second component.
 14. The method of claim 12, wherein the first component or the second component are any one of: a finite state machine; a multiplexer device; a storage register; or a configuration and settings register.
 15. The method of claim 12, wherein the sparsely encoded signal is indicative of: a handshake between the first component and the second component; a register setting configured by one of the first component or second component; a write enabled control signal between the first component and the second component; or a multiplexer selector control signal between the first component and the second component.
 16. The method of claim 12, wherein: the second data line is a negated data line; and transmitting the second signal comprises: inverting the second bit of the sparsely encoded signal; and transmitting a third signal that is indicative of the inverted second bit of the sparsely encoded signal.
 17. The method of claim 12, further comprising: comparing, based on the first signal and the second signal and by a check module of the integrated circuit, the sparsely encoded signal and a predetermined set of valid states stored by the check module; and determining whether the sparsely encoded signal matches any valid state of the predetermined set of valid states.
 18. The method of claim 17, further comprising: in response to the determination that the sparsely encoded signal matches any valid state of the predetermined set of valid states, receiving the first signal and the second signal at the second component.
 19. The method of claim 17, further comprising: in response to the determination that the sparsely encoded signal does not match any valid state of the predetermined set of valid states, outputting an error to the integrated circuit.
 20. The method of claim 19, wherein outputting the error to the integrated circuit comprises storing an indication of the error in a memory of the integrated circuit. 